home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xroach-v12 / xroach.patch1 < prev   
Encoding:
Text File  |  1995-06-20  |  11.0 KB  |  461 lines
  1. *** patchlevel.h    Tue Apr 02 11:59:19 1991
  2. --- ../xroach/patchlevel.h    Tue Apr 02 11:57:25 1991
  3. ***************
  4. *** 1 ****
  5. ! #define PATCHLEVEL 0
  6. --- 1,4 ----
  7. ! 
  8. ! /* @(#)patchlevel.h    1.2 4/2/91 11:57:18 */
  9. ! 
  10. ! #define PATCHLEVEL 1
  11. *** roachmap.h    Tue Apr 02 11:59:19 1991
  12. --- ../xroach/roachmap.h    Tue Apr 02 11:55:42 1991
  13. ***************
  14. *** 1,3 ****
  15. --- 1,6 ----
  16. + 
  17. + /* @(#)roachmap.h    1.3 4/2/91 11:55:35 */
  18. + 
  19.   #include "roach000.xbm"
  20.   #include "roach015.xbm"
  21.   #include "roach030.xbm"
  22. ***************
  23. *** 22,27 ****
  24. --- 25,32 ----
  25.   #include "roach315.xbm"
  26.   #include "roach330.xbm"
  27.   #include "roach345.xbm"
  28. + 
  29. + #include "squish.xbm"
  30.   
  31.   #define ROACH_HEADINGS    24    /* number of orientations */
  32.   #define ROACH_ANGLE    15    /* angle between orientations */
  33. *** xroach.c    Tue Apr 02 11:59:18 1991
  34. --- ../xroach/xroach.c    Tue Apr 02 11:53:42 1991
  35. ***************
  36. *** 12,21 ****
  37. --- 12,31 ----
  38.         cc -o xroach roach.c -lX11 [-lsocketorwhatever] [-lm] [-l...]
  39.   
  40.       Dedicated to Greg McFarlane.   (gregm@otc.otca.oz.au)
  41. +     
  42. +     Squish option contributed by Rick Petkiewizc (rick@locus.com)
  43. +     
  44. +     Virtual root code adapted from patch sent by Colin Rafferty who
  45. +     borrowed it from Tom LaStrange.  Several other folks sent similar
  46. +     fixes.
  47.   */
  48. + 
  49. + /* @(#)xroach.c    1.5 4/2/91 11:53:31 */
  50. + 
  51.   #include <X11/Xlib.h>
  52.   #include <X11/Xutil.h>
  53.   #include <X11/Xos.h>
  54. + #include <X11/Xatom.h>
  55.   
  56.   #include <stdio.h>
  57.   #include <math.h>
  58. ***************
  59. *** 49,54 ****
  60. --- 59,65 ----
  61.   unsigned int display_width, display_height;
  62.   int center_x, center_y;
  63.   GC gc;
  64. + GC gutsGC;
  65.   char *display_name = NULL;
  66.   Pixel black, white;
  67.   
  68. ***************
  69. *** 55,60 ****
  70. --- 66,74 ----
  71.   int done = 0;
  72.   int eventBlock = 0;
  73.   int errorVal = 0;
  74. + Bool squishRoach = False;
  75. + Pixmap squishMap;
  76. + Bool squishWinUp = False;
  77.   
  78.   typedef struct Roach {
  79.       RoachMap *rp;
  80. ***************
  81. *** 84,89 ****
  82. --- 98,104 ----
  83.   int CalcRootVisible();
  84.   int MarkHiddenRoaches();
  85.   Pixel AllocNamedColor();
  86. + Window FindRootWindow();
  87.   
  88.   void
  89.   main(ac, av)
  90. ***************
  91. *** 98,105 ****
  92. --- 113,123 ----
  93.       float angle;
  94.       XEvent ev;
  95.       char *roachColor = "black";
  96. +     char *gutsColor = NULL;
  97.       int nVis;
  98.       int needCalc;
  99. +     Window squishWin;
  100. +     XSetWindowAttributes xswa;
  101.       
  102.       /*
  103.          Process command line options.
  104. ***************
  105. *** 118,123 ****
  106. --- 136,147 ----
  107.       else if (strcmp(arg, "-roaches") == 0) {
  108.           maxRoaches = strtol(av[++ax], (char **)NULL, 0);
  109.       }
  110. +     else if (strcmp(arg, "-squish") == 0) {
  111. +         squishRoach = True;
  112. +     }
  113. +     else if (strcmp(arg, "-rgc") == 0) {
  114. +         gutsColor = av[++ax];
  115. +     }
  116.       else {
  117.           Usage();
  118.       }
  119. ***************
  120. *** 142,148 ****
  121.       }
  122.   
  123.       screen = DefaultScreen(display);
  124. !     rootWin = RootWindow(display, screen);
  125.       black = BlackPixel(display, screen);
  126.       white = WhitePixel(display, screen);
  127.   
  128. --- 166,172 ----
  129.       }
  130.   
  131.       screen = DefaultScreen(display);
  132. !     rootWin = FindRootWindow();
  133.       black = BlackPixel(display, screen);
  134.       white = WhitePixel(display, screen);
  135.   
  136. ***************
  137. *** 164,179 ****
  138. --- 188,229 ----
  139.       rp->cosine = cos(angle);
  140.       }
  141.   
  142. +     /*
  143. +       Create the squished pixmap
  144. +     */
  145. +     if (squishRoach) {
  146. +         squishMap = XCreateBitmapFromData(display, rootWin,
  147. +         squish_bits, squish_width, squish_height);
  148. +     }
  149. + 
  150.       roaches = (Roach *)malloc(sizeof(Roach) * maxRoaches);
  151.   
  152.       gc = XCreateGC(display, rootWin, 0L, &xgcv);
  153.       XSetForeground(display, gc, AllocNamedColor(roachColor, black));
  154.       XSetFillStyle(display, gc, FillStippled);
  155. + 
  156. +     if (squishRoach && gutsColor != NULL) {
  157. +         gutsGC = XCreateGC(display, rootWin, 0L, &xgcv);
  158. +         XSetForeground(display, gutsGC, AllocNamedColor(gutsColor, black));
  159. +         XSetFillStyle(display, gutsGC, FillStippled);
  160. +     }
  161. +     else
  162. +     gutsGC = gc;
  163.       
  164.       while (curRoaches < maxRoaches)
  165.       AddRoach();
  166.       
  167.       XSelectInput(display, rootWin, ExposureMask | SubstructureNotifyMask);
  168. + 
  169. +     if (squishRoach) {
  170. +     xswa.event_mask = ButtonPressMask;
  171. +     xswa.override_redirect = True;
  172. +     squishWin = XCreateWindow(display, rootWin, 0, 0,
  173. +             display_width, display_height, 0,
  174. +             CopyFromParent, InputOnly, CopyFromParent,
  175. +             CWOverrideRedirect | CWEventMask, &xswa);
  176. +     XLowerWindow(display, squishWin);
  177. +     }
  178.       
  179.       needCalc = 1;
  180.       while (!done) {
  181. ***************
  182. *** 184,195 ****
  183.           if (needCalc) {
  184.           needCalc = CalcRootVisible();
  185.           }
  186. !         nVis = MarkHiddenRoaches();
  187.           if (nVis) {
  188.           ev.type = SCAMPER_EVENT;
  189.           }
  190.           else {
  191. !         DrawRoaches();
  192.           eventBlock = 1;
  193.           XNextEvent(display, &ev);
  194.           eventBlock = 0;
  195. --- 234,257 ----
  196.           if (needCalc) {
  197.           needCalc = CalcRootVisible();
  198.           }
  199. !         if (needCalc)
  200. !         nVis = 0;
  201. !         else
  202. !             nVis = MarkHiddenRoaches();
  203.           if (nVis) {
  204.           ev.type = SCAMPER_EVENT;
  205. +         if (!squishWinUp && squishRoach) {
  206. +             XMapWindow(display, squishWin);
  207. +             squishWinUp = True;
  208. +         }
  209.           }
  210.           else {
  211. !         if (squishWinUp && squishRoach) {
  212. !             XUnmapWindow(display, squishWin);
  213. !             squishWinUp = False;
  214. !         }
  215. !         if (needCalc == 0)
  216. !             DrawRoaches();
  217.           eventBlock = 1;
  218.           XNextEvent(display, &ev);
  219.           eventBlock = 0;
  220. ***************
  221. *** 207,218 ****
  222.           XSync(display, False);
  223.           break;
  224.           
  225. -         case Expose:
  226. -         case MapNotify:
  227.           case UnmapNotify:
  228.           case ConfigureNotify:
  229.           needCalc = 1;
  230.           break;
  231.           
  232.       }
  233.       }
  234. --- 269,288 ----
  235.           XSync(display, False);
  236.           break;
  237.           
  238.           case UnmapNotify:
  239. +         if (ev.xunmap.window != squishWin)
  240. +             needCalc = 1;
  241. +         break;
  242. + 
  243. +         case MapNotify:
  244. +         case Expose:
  245.           case ConfigureNotify:
  246.           needCalc = 1;
  247.           break;
  248. +     
  249. +         case ButtonPress:
  250. +         checkSquish(&ev);
  251. +         break;
  252.           
  253.       }
  254.       }
  255. ***************
  256. *** 233,238 ****
  257. --- 303,310 ----
  258.       USEPRT("       -rc      roachcolor\n");
  259.       USEPRT("       -roaches numroaches\n");
  260.       USEPRT("       -speed   roachspeed\n");
  261. +     USEPRT("       -squish\n");
  262. +     USEPRT("       -rgc     roachgutscolor\n");
  263.       
  264.       exit(1);
  265.   }
  266. ***************
  267. *** 256,261 ****
  268. --- 328,391 ----
  269.   }
  270.   
  271.   /*
  272. +    Find the root or virtual root window.
  273. + */
  274. + Window
  275. + FindRootWindow()
  276. + {
  277. +     Window rootWin;
  278. +     Window realRoot;
  279. +     Atom swmVroot;
  280. +     Window rootReturn, parentReturn, *children;
  281. +     unsigned int numChildren;
  282. +     int cx;
  283. +     Atom actualType;
  284. +     Atom actualFormat;
  285. +     unsigned long nItems;
  286. +     unsigned long bytesAfter;
  287. +     Window *newRoot;
  288. +     
  289. +     /*
  290. +        Get real root window.
  291. +     */
  292. +     realRoot = rootWin = RootWindow(display, screen);
  293. +     
  294. +     /*
  295. +        Get atom for virtual root property.  If the atom doesn't
  296. +        exist, we can assume the corresponding property does not
  297. +        exist. 
  298. +     */
  299. +     swmVroot = XInternAtom(display, "__SWM_VROOT", True);
  300. +     
  301. +     if (swmVroot == None)
  302. +     return rootWin;
  303. +     
  304. +     /*
  305. +        Run children of root, looking for a virtual root.
  306. +     */
  307. +     XQueryTree(display, rootWin, &rootReturn, &parentReturn, 
  308. +             &children, &numChildren);
  309. +     for (cx=0; cx<numChildren; cx++) {
  310. +     newRoot = NULL;
  311. +     nItems = 0;
  312. +     if (XGetWindowProperty(display, children[cx], swmVroot, 0L, 1L, False,
  313. +         XA_WINDOW, &actualType, &actualFormat, &nItems,
  314. +         &bytesAfter, &newRoot) == Success && actualFormat != None) {
  315. +         if (nItems >= 1) {
  316. +             rootWin = *newRoot;
  317. +         }
  318. +         if (newRoot) {
  319. +             XFree(newRoot);
  320. +         }
  321. +     }
  322. +     if (rootWin != realRoot) break;
  323. +     }
  324. +     XFree(children);
  325. +     
  326. +     return rootWin;
  327. + }
  328. + 
  329. + /*
  330.      Generate random integer between 0 and maxVal-1.
  331.   */
  332.   int
  333. ***************
  334. *** 404,410 ****
  335.       for (rx=0; rx<curRoaches; rx++) {
  336.       roach = &roaches[rx];
  337.       
  338. !     if (roach->intX >= 0) {
  339.           XClearArea(display, rootWin, roach->intX, roach->intY,
  340.           roach->rp->width, roach->rp->height, False);
  341.       }
  342. --- 534,540 ----
  343.       for (rx=0; rx<curRoaches; rx++) {
  344.       roach = &roaches[rx];
  345.       
  346. !     if (roach->intX >= 0 && roach->rp != NULL) {
  347.           XClearArea(display, rootWin, roach->intX, roach->intY,
  348.           roach->rp->width, roach->rp->height, False);
  349.       }
  350. ***************
  351. *** 505,515 ****
  352.       */
  353.       covered = XCreateRegion();
  354.       for (wx=0; wx<nChildren; wx++) {
  355. !     if (XEventsQueued(display, QueuedAlready)) return 1;
  356.       errorVal = 0;
  357.       XGetWindowAttributes(display, children[wx], &wa);
  358.       if (errorVal) continue;
  359. !     if (wa.map_state == IsViewable) {
  360.           XGetGeometry(display, children[wx], &dummy, &winX, &winY,
  361.           &winWidth, &winHeight, &borderWidth, &depth);
  362.           if (errorVal) continue;
  363. --- 635,648 ----
  364.       */
  365.       covered = XCreateRegion();
  366.       for (wx=0; wx<nChildren; wx++) {
  367. !     if (XEventsQueued(display, QueuedAlready)) {
  368. !         XDestroyRegion(covered);
  369. !         return 1;
  370. !     }
  371.       errorVal = 0;
  372.       XGetWindowAttributes(display, children[wx], &wa);
  373.       if (errorVal) continue;
  374. !     if (wa.class == InputOutput && wa.map_state == IsViewable) {
  375.           XGetGeometry(display, children[wx], &dummy, &winX, &winY,
  376.           &winWidth, &winHeight, &borderWidth, &depth);
  377.           if (errorVal) continue;
  378. ***************
  379. *** 606,609 ****
  380. --- 739,783 ----
  381.       }
  382.   
  383.       return pix;
  384. + }
  385. + 
  386. + /*
  387. +  *    squishCheck - Check to see if we have to squish any roaches.
  388. +  */
  389. + checkSquish(buttonEvent)
  390. + XButtonEvent *buttonEvent;
  391. + {
  392. +     int x, y;
  393. +     int i;
  394. +     int rx;
  395. +     Roach *r;
  396. + /* */
  397. +     x = buttonEvent->x;
  398. +     y = buttonEvent->y;
  399. + 
  400. +     for (rx=0; rx<curRoaches; rx++) {
  401. +     r = &roaches[rx];
  402. +     if (r->rp == NULL) continue;
  403. + 
  404. +     if (x > r->intX &&
  405. +         x < (r->intX + r->rp->width) &&
  406. +         y > r->intY &&
  407. +         y < (r->intY + r->rp->height)) {
  408. +         XSetStipple(display, gutsGC, squishMap);
  409. +         XSetTSOrigin(display, gutsGC, r->intX, r->intY);
  410. +         XFillRectangle(display, rootWin, gutsGC,
  411. +         r->intX, r->intY, squish_width, squish_height);
  412. + 
  413. +         /*
  414. +          * Delete the roach
  415. +          */
  416. +         for (i = rx; i < curRoaches - 1; i++)
  417. +             roaches[i] = roaches[i + 1];
  418. +     
  419. +         curRoaches--;
  420. +         rx--;
  421. +     }
  422. +     }
  423. + 
  424. +     return;
  425.   }
  426. *** xroach.man    Tue Apr 02 12:26:11 1991
  427. --- ../xroach/xroach.man    Tue Apr 02 12:46:43 1991
  428. ***************
  429. *** 9,15 ****
  430.   displays disgusting cockroaches on your root window. These creapy crawlies
  431.   scamper
  432.   around until they find a window to hide under. Whenever you move or iconify
  433. ! a window, the exposed beetles again scamper for cover.
  434.   .SH OPTIONS
  435.   .TP 8
  436.   .B \-display \fIdisplay_name\fB
  437. --- 9,15 ----
  438.   displays disgusting cockroaches on your root window. These creapy crawlies
  439.   scamper
  440.   around until they find a window to hide under. Whenever you move or iconify
  441. ! a window, the exposed orthopteras again scamper for cover.
  442.   .SH OPTIONS
  443.   .TP 8
  444.   .B \-display \fIdisplay_name\fB
  445. ***************
  446. *** 26,31 ****
  447. --- 26,38 ----
  448.   .TP 8
  449.   .B \-roaches \fInum_roaches\fB
  450.   This is the number of the little critters. Default is 10.
  451. + .TP 8
  452. + .B \-squish
  453. + Enables roach squishing.  Point and shoot with any mouse button.
  454. + .TP 8
  455. + .B \-rgc \fIroach_gut_color\fB
  456. + Sets color of the guts that spill out of squished roaches.  We recommend
  457. + yellowgreen.
  458.   .SH BUGS
  459.   As given by the -roaches option. Default is 10.
  460.   .SH COPYRIGHT
  461.